// utils/index.js - 工具集中导出

import token from './token';
import storage from './storage';
import wxAuth from './wxAuth';
import date from './date';
import system from './system';
import address from './address';
import message from './message';

// 验证工具
const validate = {
  // 手机号验证
  isPhoneNumber(value) {
    return /^1[3-9]\d{9}$/.test(value);
  },
  
  // 邮箱验证
  isEmail(value) {
    return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(value);
  },
  
  // 密码强度验证（至少包含字母和数字，长度至少为6位）
  isStrongPassword(value) {
    return /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{6,}$/.test(value);
  },
  
  // 身份证号码验证
  isIdCard(value) {
    return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(value);
  },
  
  // URL验证
  isUrl(value) {
    return /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w.-]*)*\/?$/.test(value);
  },
  
  // 数字验证
  isNumber(value) {
    return !isNaN(parseFloat(value)) && isFinite(value);
  },
  
  // 整数验证
  isInteger(value) {
    return Number.isInteger(Number(value));
  },
  
  // 正整数验证
  isPositiveInteger(value) {
    return /^[1-9]\d*$/.test(value);
  },
  
  // 非空验证
  isNotEmpty(value) {
    return value !== null && value !== undefined && value !== '';
  }
};

// 格式化工具
const format = {
  // 格式化日期时间
  formatDateTime(date, format = 'YYYY-MM-DD HH:mm:ss') {
    return date.formatDate(date, format);
  },
  
  // 格式化数字（添加千位分隔符）
  formatNumber(num) {
    return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  },
  
  // 格式化金额（保留两位小数）
  formatMoney(num) {
    return parseFloat(num).toFixed(2).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  },
  
  // 格式化文件大小
  formatFileSize(size) {
    if (size < 1024) {
      return size + 'B';
    } else if (size < 1024 * 1024) {
      return (size / 1024).toFixed(2) + 'KB';
    } else if (size < 1024 * 1024 * 1024) {
      return (size / (1024 * 1024)).toFixed(2) + 'MB';
    } else {
      return (size / (1024 * 1024 * 1024)).toFixed(2) + 'GB';
    }
  },
  
  // 格式化手机号（隐藏中间四位）
  formatPhone(phone) {
    if (!phone) return '';
    return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
  },
  
  // 格式化银行卡号（每4位添加空格）
  formatBankCard(card) {
    if (!card) return '';
    return card.replace(/\s/g, '').replace(/(\d{4})(?=\d)/g, '$1 ');
  },
  
  // 格式化身份证（隐藏出生日期）
  formatIdCard(idCard) {
    if (!idCard) return '';
    return idCard.replace(/(\d{6})\d{8}(\d{4})/, '$1********$2');
  }
};

// 对象工具
const object = {
  // 深拷贝
  deepClone(obj) {
    if (obj === null || typeof obj !== 'object') {
      return obj;
    }
    
    if (obj instanceof Date) {
      return new Date(obj.getTime());
    }
    
    if (obj instanceof Array) {
      return obj.map(item => this.deepClone(item));
    }
    
    if (obj instanceof Object) {
      const copy = {};
      Object.keys(obj).forEach(key => {
        copy[key] = this.deepClone(obj[key]);
      });
      return copy;
    }
    
    return obj;
  },
  
  // 合并对象
  merge(...objects) {
    return Object.assign({}, ...objects);
  },
  
  // 对象转查询字符串
  toQueryString(obj) {
    if (!obj) return '';
    
    const parts = [];
    Object.keys(obj).forEach(key => {
      const value = obj[key];
      if (value !== null && value !== undefined) {
        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
      }
    });
    
    return parts.join('&');
  },
  
  // 查询字符串转对象
  fromQueryString(str) {
    if (!str) return {};
    
    const result = {};
    str.split('&').forEach(part => {
      const [key, value] = part.split('=');
      result[decodeURIComponent(key)] = decodeURIComponent(value);
    });
    
    return result;
  }
};

// 字符串工具
const string = {
  // 生成随机字符串
  random(length = 16, chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
    let result = '';
    const charsLength = chars.length;
    
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * charsLength));
    }
    
    return result;
  },
  
  // 生成UUID
  uuid() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
      const r = Math.random() * 16 | 0;
      const v = c === 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  },
  
  // 截取字符串（考虑中文）
  truncate(str, length, suffix = '...') {
    if (!str) return '';
    
    if (str.length <= length) {
      return str;
    }
    
    return str.substring(0, length) + suffix;
  },
  
  // 转换为驼峰命名
  toCamelCase(str) {
    return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
  },
  
  // 转换为下划线命名
  toSnakeCase(str) {
    return str.replace(/[A-Z]/g, c => `_${c.toLowerCase()}`);
  }
};

// 数组工具
const array = {
  // 数组去重
  unique(arr) {
    return [...new Set(arr)];
  },
  
  // 数组分组
  groupBy(arr, key) {
    return arr.reduce((result, item) => {
      const groupKey = typeof key === 'function' ? key(item) : item[key];
      
      if (!result[groupKey]) {
        result[groupKey] = [];
      }
      
      result[groupKey].push(item);
      return result;
    }, {});
  },
  
  // 数组排序
  sortBy(arr, key, desc = false) {
    const copy = [...arr];
    
    copy.sort((a, b) => {
      const valueA = typeof key === 'function' ? key(a) : a[key];
      const valueB = typeof key === 'function' ? key(b) : b[key];
      
      if (valueA < valueB) {
        return desc ? 1 : -1;
      }
      
      if (valueA > valueB) {
        return desc ? -1 : 1;
      }
      
      return 0;
    });
    
    return copy;
  }
};

// 设备信息
const device = {
  // 获取系统信息
  getSystemInfo() {
    return system.getSystemInfo();
  },
  
  // 判断是否是iOS设备
  isIOS() {
    return system.isIOS();
  },
  
  // 判断是否是Android设备
  isAndroid() {
    return system.isAndroid();
  }
};

export {
  token,
  storage,
  wxAuth,
  date,
  system,
  address,
  message,
  validate,
  format,
  object,
  string,
  array,
  device
};